home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / STUTTGART / TEMP / GNU / bison / PureCallin < prev    next >
Text File  |  1995-06-28  |  3KB  |  112 lines
  1. Pure Calling
  2. Previous: <Token Positions=>TokenPosit> * Next: <Error Reporting=>ErrorRepor> * Up: <Lexical=>Lexical>
  3.  
  4. #Wrap on
  5. {fH4}Calling Conventions for Pure Parsers{f}
  6.  
  7. When you use the Bison declaration {fCode}%pure\_parser{f} to request a
  8. pure, reentrant parser, the global communication variables {fCode}yylval{f}
  9. and {fCode}yylloc{f} cannot be used.  (\*Note <Pure Decl=>PureDecl>: A Pure (Reentrant) Parser.)  In such parsers the two global variables are replaced by
  10. pointers passed as arguments to {fCode}yylex{f}.  You must declare them as
  11. shown here, and pass the information back by storing it through those
  12. pointers.
  13.  
  14. #Wrap off
  15. #fCode
  16. yylex (lvalp, llocp)
  17.      YYSTYPE \*lvalp;
  18.      YYLTYPE \*llocp;
  19. \{
  20.   …
  21.   \*lvalp = value;  \/\* Put value onto Bison stack.  \*\/
  22.   return INT;      \/\* Return the type of the token.  \*\/
  23.   …
  24. \}
  25. #f
  26. #Wrap on
  27.  
  28. If the grammar file does not use the {fEmphasis}@{f} constructs to refer to
  29. textual positions, then the type {fCode}YYLTYPE{f} will not be defined.  In
  30. this case, omit the second argument; {fCode}yylex{f} will be called with
  31. only one argument.
  32.  
  33. You can pass parameter information to a reentrant parser in a reentrant
  34. way.  Define the macro {fCode}YYPARSE\_PARAM{f} as a variable name.  The
  35. resulting {fCode}yyparse{f} function then accepts one argument, of type
  36. {fCode}void \*{f}, with that name.
  37.  
  38. When you call {fCode}yyparse{f}, pass the address of an object, casting the
  39. address to {fCode}void \*{f}.  The grammar actions can refer to the contents
  40. of the object by casting the pointer value back to its proper type and
  41. then dereferencing it.  Here's an example.  Write this in the parser:
  42.  
  43. #Wrap off
  44. #fCode
  45. %\{
  46. struct parser\_control
  47. \{
  48.   int nastiness;
  49.   int randomness;
  50. \};
  51.  
  52. \#define YYPARSE\_PARAM parm
  53. %\}
  54. #f
  55. #Wrap on
  56.  
  57. Then call the parser like this:
  58.  
  59. #Wrap off
  60. #fCode
  61. struct parser\_control
  62. \{
  63.   int nastiness;
  64.   int randomness;
  65. \};
  66.  
  67. …
  68.  
  69. \{
  70.   struct parser\_control foo;
  71.   …  \/\* Store proper data in {fCode}foo{f}.  \*\/
  72.   value = yyparse ((void \*) &foo);
  73.   …
  74. \}
  75. #f
  76. #Wrap on
  77.  
  78. In the grammar actions, use expressions like this to refer to the data:
  79.  
  80. #Wrap off
  81. #fCode
  82. ((struct parser\_control \*) parm)->randomness
  83. #f
  84. #Wrap on
  85.  
  86. If you wish to pass the additional parameter data to {fCode}yylex{f},
  87. define the macro {fCode}YYLEX\_PARAM{f} just like {fCode}YYPARSE\_PARAM{f}, as
  88. shown here:
  89.  
  90. #Wrap off
  91. #fCode
  92. %\{
  93. struct parser\_control
  94. \{
  95.   int nastiness;
  96.   int randomness;
  97. \};
  98.  
  99. \#define YYPARSE\_PARAM parm
  100. \#define YYLEX\_PARAM parm
  101. %\}
  102. #f
  103. #Wrap on
  104.  
  105. You should then define {fCode}yylex{f} to accept one additional
  106. argument---the value of {fCode}parm{f}.  (This makes either two or three
  107. arguments in total, depending on whether an argument of type
  108. {fCode}YYLTYPE{f} is passed.)  You can declare the argument as a pointer to
  109. the proper object type, or you can declare it as {fCode}void \*{f} and
  110. access the contents as shown above.
  111.  
  112.